home *** CD-ROM | disk | FTP | other *** search
/ Aminet 28 / Aminet 28 (1998)(GTI - Schatztruhe)[!][Dec 1998].iso / Aminet / dev / misc / Compressor.lha / CompressorClass / Examples / Amiga-E / Class_Test.e next >
Encoding:
Text File  |  1998-09-23  |  32.6 KB  |  1,054 lines
  1. /* -- ----------------------------------------------------------------- -- *
  2.  * -- Program.....: Class_Test.e                                        -- *
  3.  * -- Author......: Daniel Kasmeroglu <raptor@cs.tu-berlin.de>          -- *
  4.  * -- Description.: Demonstration of the Compressor.class               -- *
  5.  * -- ----------------------------------------------------------------- -- *
  6.  * -- History                                                           -- *
  7.  * --                                                                   -- *
  8.  * --   0.1 (31. August    1998) - Started with writing.                -- *
  9.  * --   1.0 (17. September 1998) - Finished writing.                    -- *
  10.  * --                                                                   -- *
  11.  * -- ----------------------------------------------------------------- -- */
  12.  
  13.  
  14. /* -- ----------------------------------------------------------------- -- *
  15.  * --                              Options                              -- *
  16.  * -- ----------------------------------------------------------------- -- */
  17.  
  18. OPT PREPROCESS       -> enable preprocessor
  19. OPT REG = 5          -> register-optimisation
  20.  
  21.  
  22. /* -- ----------------------------------------------------------------- -- *
  23.  * --                              Modules                              -- *
  24.  * -- ----------------------------------------------------------------- -- */
  25.  
  26. MODULE 'intuition/classusr',
  27.        'intuition/classes',
  28.        'amigalib/boopsi',
  29.        'libraries/iffparse',
  30.        'libraries/xpk',
  31.        'tools/inithook',
  32.        'global/qstringf',
  33.        'exec/memory',
  34.        'graphics/text',
  35.        'utility/tagitem',
  36.        'utility/hooks',
  37.        'prefs/prefhdr'
  38.  
  39. MODULE 'lib/iffparse'
  40.  
  41. MODULE 'classes/compressor',
  42.        'lib/compressor'
  43.  
  44.  
  45. /* -- ----------------------------------------------------------------- -- *
  46.  * --                             Constants                             -- *
  47.  * -- ----------------------------------------------------------------- -- */
  48.  
  49. CONST ERR_LIB       = "LIB " ,
  50.       ERR_ARGS      = "ARGS" ,
  51.       ERR_NOWB      = "NOWB" ,
  52.       ERR_CLASS     = "CLAS"
  53.  
  54. CONST NUMFILES  = 4,  -> number of files to be generated
  55.       NILLIST   = 11, -> NUMFILES + 1
  56.       SIZESHIFT = 4   -> filesize = available mem / 2^SIZESHIFT
  57.  
  58.  
  59. /* -- ----------------------------------------------------------------- -- *
  60.  * --                           Declarations                            -- *
  61.  * -- ----------------------------------------------------------------- -- */
  62.  
  63. DEF glo_clihook,glo_mempool
  64.  
  65.  
  66. /* -- ----------------------------------------------------------------- -- *
  67.  * --                           Hook-Routines                           -- *
  68.  * -- ----------------------------------------------------------------- -- */
  69.  
  70. ->»» PROC hoo_CLIProgress
  71. PROC hoo_CLIProgress( cli_hook, cli_object, cli_msg : PTR TO xpkprogress )
  72.  
  73.   IF cli_msg.type = XPKPROG_START
  74.     help_ClearCON()
  75.     WriteF( '\n\tFile....: "\s"\n'    , cli_msg.filename )
  76.     WriteF( '\tSize....: \d Bytes\n'  , cli_msg.ulen     )
  77.     WriteF( '\c\tDone....: \r\d[3] %' , 13, cli_msg.done )
  78.   ELSE
  79.     WriteF( '\c\tDone....: \r\d[3] %' , 13, cli_msg.done )
  80.   ENDIF
  81.  
  82.   -> user wants to abort ?
  83.   IF CtrlC() <> FALSE
  84.     WriteF( '\n\tCompression aborted !\n' )
  85.     RETURN 1
  86.   ENDIF
  87.  
  88.   IF cli_msg.type = XPKPROG_END
  89.     WriteF( '\n\tEnd of (de)compression !\n' )
  90.   ENDIF
  91.  
  92. ENDPROC 0
  93. ->»»>
  94.  
  95.  
  96. /* -- ----------------------------------------------------------------- -- *
  97.  * --                         Helping Routines                          -- *
  98.  * -- ----------------------------------------------------------------- -- */
  99.  
  100. ->»» PROC help_ShowXPKError
  101. -> Simply prints out the name of the passed XPK-Error.
  102. -> It's much more helpful then showing a negative value.
  103. PROC help_ShowXPKError( sho_value )
  104.  
  105.   SELECT sho_value
  106.   CASE XPKERR_NOFUNC       ; WriteF( 'XPKERR_NOFUNC\n'      )
  107.   CASE XPKERR_NOFILES      ; WriteF( 'XPKERR_NOFILES\n'     )
  108.   CASE XPKERR_IOERRIN      ; WriteF( 'XPKERR_IOERRIN\n'     )
  109.   CASE XPKERR_IOERROUT     ; WriteF( 'XPKERR_IOERROUT\n'    )
  110.   CASE XPKERR_CHECKSUM     ; WriteF( 'XPKERR_CHECKSUM\n'    )
  111.   CASE XPKERR_VERSION      ; WriteF( 'XPKERR_VERSION\n'     )
  112.   CASE XPKERR_NOMEM        ; WriteF( 'XPKERR_NOMEM\n'       )
  113.   CASE XPKERR_LIBINUSE     ; WriteF( 'XPKERR_LIBINUSE\n'    )
  114.   CASE XPKERR_WRONGFORM    ; WriteF( 'XPKERR_WRONGFORM\n'   )
  115.   CASE XPKERR_SMALLBUF     ; WriteF( 'XPKERR_SMALLBUF\n'    )
  116.   CASE XPKERR_LARGEBUF     ; WriteF( 'XPKERR_LARGEBUF\n'    )
  117.   CASE XPKERR_WRONGMODE    ; WriteF( 'XPKERR_WRONGMODE\n'   )
  118.   CASE XPKERR_NEEDPASSWD   ; WriteF( 'XPKERR_NEEDPASSWD\n'  )
  119.   CASE XPKERR_CORRUPTPKD   ; WriteF( 'XPKERR_CORRUPTPKD\n'  )
  120.   CASE XPKERR_MISSINGLIB   ; WriteF( 'XPKERR_MISSINGLIB\n'  )
  121.   CASE XPKERR_BADPARAMS    ; WriteF( 'XPKERR_BADPARAMS\n'   )
  122.   CASE XPKERR_EXPANSION    ; WriteF( 'XPKERR_EXPANSION\n'   )
  123.   CASE XPKERR_NOMETHOD     ; WriteF( 'XPKERR_NOMETHOD\n'    )
  124.   CASE XPKERR_ABORTED      ; WriteF( 'XPKERR_ABORTED\n'     )
  125.   CASE XPKERR_TRUNCATED    ; WriteF( 'XPKERR_TRUNCATED\n'   )
  126.   CASE XPKERR_WRONGCPU     ; WriteF( 'XPKERR_WRONGCPU\n'    )
  127.   CASE XPKERR_PACKED       ; WriteF( 'XPKERR_PACKED\n'      )
  128.   CASE XPKERR_NOTPACKED    ; WriteF( 'XPKERR_NOTPACKED\n'   )
  129.   CASE XPKERR_FILEEXISTS   ; WriteF( 'XPKERR_FILEEXISTS\n'  )
  130.   CASE XPKERR_OLDMASTLIB   ; WriteF( 'XPKERR_OLDMASTLIB\n'  )
  131.   CASE XPKERR_OLDSUBLIB    ; WriteF( 'XPKERR_OLDSUBLIB\n'   )
  132.   CASE XPKERR_NOCRYPT      ; WriteF( 'XPKERR_NOCRYPT\n'     )
  133.   CASE XPKERR_NOINFO       ; WriteF( 'XPKERR_NOINFO\n'      )
  134.   CASE XPKERR_LOSSY        ; WriteF( 'XPKERR_LOSSY\n'       )
  135.   CASE XPKERR_NOHARDWARE   ; WriteF( 'XPKERR_NOHARDWARE\n'  )
  136.   CASE XPKERR_BADHARDWARE  ; WriteF( 'XPKERR_BADHARDWARE\n' )
  137.   CASE XPKERR_WRONGPW      ; WriteF( 'XPKERR_WRONGPW\n'     )
  138.   DEFAULT                  ; WriteF( 'If you can read this, you should contact the author !\n' )
  139.   ENDSELECT
  140.  
  141. ENDPROC
  142. ->»»>
  143.  
  144. ->»» PROC help_WriteDummyFile
  145. -> This little routines writes files of a given size.
  146. -> The files are filled with shit but they may be
  147. -> used for demonstrations.
  148. PROC help_WriteDummyFile( gen_file, gen_size )
  149. DEF gen_mem,gen_han
  150.  
  151.   -> allocate memory with the requested size
  152.   gen_mem := AllocMem( gen_size, 0 )
  153.   IF gen_mem <> NIL
  154.  
  155.     -> open the file
  156.     gen_han := Open( gen_file, NEWFILE )
  157.     IF gen_han <> NIL
  158.       -> write the memory area into this file
  159.       Write( gen_han, gen_mem, gen_size )
  160.       Close( gen_han )
  161.     ENDIF
  162.     FreeMem( gen_mem, gen_size )
  163.  
  164.   ENDIF
  165.  
  166.   -> was writing successful
  167.   IF FileLength( gen_file ) = gen_size
  168.     RETURN TRUE
  169.   ELSE
  170.     DeleteFile( gen_file )
  171.   ENDIF
  172.  
  173. ENDPROC FALSE
  174. ->»»>
  175.  
  176. ->»» PROC help_WaitReturn
  177. -> Stupid function which waits for a RETURN.
  178. PROC help_WaitReturn()
  179. DEF wai_buff[ 3 ] : STRING
  180.   WriteF( '\n\n< PRESS RETURN TO CONTINUE > ' )
  181.   ReadStr( stdin, wai_buff )
  182. ENDPROC
  183. ->»»>
  184.  
  185. ->»» PROC help_ClearCON
  186. -> Simply clears the consolewindow.
  187. PROC help_ClearCON() IS WriteF( '\e[0;0H\e[J' )
  188. ->»»>
  189.  
  190. ->»» PROC help_LoadFile
  191. PROC help_LoadFile( loa_path )
  192. DEF loa_mem,loa_size,loa_han
  193.  
  194.   loa_size := FileLength( loa_path )
  195.   loa_mem  := AllocMem( loa_size, MEMF_PUBLIC )
  196.   IF loa_mem <> NIL
  197.  
  198.     loa_han := Open( loa_path, OLDFILE )
  199.     IF loa_han <> NIL
  200.       IF Read( loa_han, loa_mem, loa_size ) <> loa_size
  201.         FreeMem( loa_mem, loa_size )
  202.         loa_mem  := NIL
  203.         loa_size := 0
  204.       ENDIF
  205.       Close( loa_han )
  206.     ELSE
  207.       FreeMem( loa_mem, loa_size )
  208.       loa_mem  := NIL
  209.       loa_size := 0
  210.     ENDIF
  211.  
  212.   ENDIF
  213.  
  214. ENDPROC loa_mem,loa_size
  215. ->»»>
  216.  
  217.  
  218. /* -- ----------------------------------------------------------------- -- *
  219.  * --                          Demonstrations                           -- *
  220.  * -- ----------------------------------------------------------------- -- */
  221.  
  222. ->»» PROC dem_ShowConfiguration
  223. PROC dem_ShowConfiguration( dem_object )
  224. DEF dem_packerinfo : PTR TO xpkpackerinfo
  225. DEF dem_packermode : PTR TO xpkmode
  226. DEF dem_mode,dem_method
  227.  
  228.   -> This procedure simply gets some information from the given
  229.   -> object and prints them out. It's very simpel as you can see.
  230.  
  231.   GetAttr ( CCA_METHOD , dem_object , {dem_method} )
  232.   WriteF  ( '\n\n\tMethod..............: "\s"\n' , dem_method )
  233.  
  234.   GetAttr ( CCA_XPKPACKERINFO , dem_object , {dem_packerinfo} )
  235.   WriteF  ( '\tLongName............: \s\n' , dem_packerinfo.longname )
  236.   WriteF  ( '\tDescription.........: \s\n' , dem_packerinfo.description )
  237.  
  238.   GetAttr ( CCA_MODE, dem_object, {dem_mode} )
  239.   WriteF  ( '\tMode................: \d\n', dem_mode )
  240.  
  241.   GetAttr ( CCA_XPKMODE, dem_object, {dem_packermode} )
  242.   WriteF  ( '\tMode-Description....: \s\n', dem_packermode.description )
  243.  
  244.   WriteF  ( '\tEncryption..........: \s\n', IF (dem_packerinfo.flags AND XPKIF_ENCRYPTION) <> NIL THEN 'possible' ELSE 'not possible' )
  245.  
  246.   GetAttr( CCA_PASSWORD, dem_object, {dem_method} )
  247.   WriteF( '\tPassword............: "\s"\n', dem_method )
  248.  
  249.   GetAttr( CCA_MEMPOOL, dem_object, {dem_method} )
  250.   WriteF( '\tMemory pool.........: \s\n', IF dem_method <> NIL THEN 'installed' ELSE 'not installed' )
  251.   GetAttr( CCA_PROGRESSHOOK, dem_object, {dem_method} )
  252.   WriteF( '\tProgress-Hook.......: \s\n', IF dem_method <> NIL THEN 'installed' ELSE 'not installed' )
  253.  
  254.   GetAttr( CCA_HIDEPASSWORD, dem_object, {dem_method} )
  255.   WriteF( '\tFlags...............: \s', IF dem_method <> FALSE THEN 'CCF_HIDEPASSWORD\n\t                      ' ELSE '' )
  256.  
  257.   GetAttr( CCA_INTERNALPROGRESS, dem_object, {dem_method} )
  258.   WriteF( '\s', IF dem_method <> FALSE THEN 'CCF_INTERNALPROGRESS\n\t                      ' ELSE '' )
  259.  
  260.   GetAttr( CCA_SCREENLOCKED, dem_object, {dem_method} )
  261.   WriteF( '\s', IF dem_method <> FALSE THEN 'CCF_SCREENLOCKED\n' ELSE '' )
  262.  
  263.   help_WaitReturn()
  264.  
  265. ENDPROC
  266. ->»»>
  267.  
  268. ->»» PROC dem_SelectMethod
  269. PROC dem_SelectMethod( dem_object )
  270. DEF dem_buff[ 4 ] : STRING
  271. DEF dem_list      : PTR TO LONG
  272. DEF dem_count,dem_selected
  273. DEF dem_choice,dem_run
  274.  
  275.   GetAttr( CCA_METHODLIST, dem_object, {dem_list}  )
  276.   GetAttr( CCA_NUMPACKERS, dem_object, {dem_count} )
  277.  
  278.   dem_selected := FALSE
  279.   WHILE dem_selected = FALSE
  280.  
  281.     help_ClearCON()
  282.  
  283.     WriteF( '\n\tSelect a method by entering the preceding number !\n\n' )
  284.  
  285.     -> print out the list of available packer
  286.     WriteF( '\n\t' )
  287.     FOR dem_run := 1 TO dem_count
  288.       WriteF( ' \r\d[3]. \s   ', dem_run, dem_list[ dem_run - 1 ] )
  289.       IF Mod( dem_run, 5 ) = 0 THEN WriteF( '\n\t' )
  290.     ENDFOR
  291.  
  292.     WriteF( '\n\n\tYour choice => ' )
  293.     ReadStr( stdin, dem_buff )
  294.     dem_choice := Val( dem_buff )
  295.     IF (dem_choice > 0) AND (dem_choice <= dem_count) THEN dem_selected := TRUE
  296.  
  297.   ENDWHILE
  298.  
  299.   -> we need the index (list starts from zero)
  300.   dem_choice := dem_choice - 1
  301.  
  302.  
  303.   -> both attributes are having the same effect, so you can use
  304.   -> both calls. naturally you only need one of the following lines
  305.   -> and you should prefer the attribute "CCA_METHODINDEX" because
  306.   -> setting this is much faster than "CCA_METHOD". the reason is
  307.   -> simple because my object have to search the method in the list
  308.   -> and this results in some string-comparisons. if you are passing
  309.   -> the name of a method which isn't available (or other shit) this
  310.   -> will be ignored. all will be left unchanged.
  311.   SetAttrsA( dem_object , [ CCA_METHODINDEX , dem_choice             , TAG_END ] )
  312.   SetAttrsA( dem_object , [ CCA_METHOD      , dem_list[ dem_choice ] , TAG_END ] )
  313.  
  314. ENDPROC
  315. ->»»>
  316.  
  317. ->»» PROC dem_SelectMode
  318. PROC dem_SelectMode( dem_object )
  319. DEF dem_buff [ 4 ] : STRING
  320. DEF dem_mode
  321.  
  322.   WriteF( '\n\tEnter a value (1..100) => ' )
  323.   ReadStr( stdin, dem_buff )
  324.   dem_mode := Val( dem_buff )
  325.  
  326.   -> setting a value lower than 1 or higher than 100 will
  327.   -> leave my object unchanged.
  328.   SetAttrsA( dem_object, [ CCA_MODE, dem_mode, TAG_END ] )
  329.  
  330. ENDPROC
  331. ->»»>
  332.  
  333. ->»» PROC dem_EnterPassword
  334. PROC dem_EnterPassword( dem_object )
  335. DEF dem_buffer[ 50 ] : STRING
  336.  
  337.   WriteF( '\n\tEnter a new password => ' )
  338.   ReadStr( stdin, dem_buffer )
  339.  
  340.   -> the passed string will be copied to the internal buffer.
  341.   SetAttrsA( dem_object, [ CCA_PASSWORD, dem_buffer, TAG_END ] )
  342.  
  343. ENDPROC
  344. ->»»>
  345.  
  346. ->»» PROC dem_ToggleHook
  347. PROC dem_ToggleHook( dem_object )
  348. DEF dem_hook
  349.  
  350.   -> switch between progresshook on and progresshook off
  351.   GetAttr( CCA_PROGRESSHOOK, dem_object, {dem_hook} )
  352.   SetAttrsA( dem_object, [ CCA_PROGRESSHOOK, IF dem_hook <> NIL THEN NIL ELSE glo_clihook, TAG_END ] )
  353.  
  354.   IF dem_hook <> NIL
  355.     WriteF( '\n\tCLI-Progress function has been removed !\n' )
  356.   ELSE
  357.     WriteF( '\n\tCLI-Progress function has been installed !\n' )
  358.   ENDIF
  359.  
  360.   help_WaitReturn()
  361.  
  362. ENDPROC
  363. ->»»>
  364.  
  365. ->»» PROC dem_PopupGUI
  366. PROC dem_PopupGUI( dem_object )
  367.  
  368.   -> the simpliest way to do the configuration
  369.   IF doMethodA( dem_object, [ CCM_PREFSGUI ] ) <> FALSE
  370.  
  371.     -> Damn, something went wrong
  372.     WriteF( '\n\tCannot launch GUI !\n' )
  373.     help_WaitReturn()
  374.  
  375.   ENDIF
  376.  
  377. ENDPROC
  378. ->»»>
  379.  
  380. ->»» PROC dem_HiddenPassword
  381. PROC dem_HiddenPassword( dem_object )
  382. DEF dem_hidden
  383.  
  384.   GetAttr( CCA_HIDEPASSWORD, dem_object, {dem_hidden} )
  385.   SetAttrsA( dem_object, [ CCA_HIDEPASSWORD, Not( dem_hidden ), TAG_END ] )
  386.  
  387.   IF dem_hidden <> FALSE
  388.     WriteF( '\n\tThe password in the GUI is now visible !\n' )
  389.   ELSE
  390.     WriteF( '\n\tThe password in the GUI is now invisible !\n' )
  391.   ENDIF
  392.  
  393.   help_WaitReturn()
  394.  
  395. ENDPROC
  396. ->»»>
  397.  
  398. ->»» PROC dem_LoadPrefs
  399. -> Both procedures are using the "iffparse.library" to write
  400. -> the IFF-File. You could use your own code instead to write
  401. -> such an IFF-File but I hope you won't write the chunk as
  402. -> raw data in your prefsfile. However, this is a little example
  403. -> that has minimal functionality but it shows how it works.
  404. PROC dem_LoadPrefs( dem_object )
  405. DEF dem_path [ 200 ] : STRING
  406. DEF dem_prhd         : PTR TO storedproperty
  407. DEF dem_cccp         : PTR TO storedproperty
  408. DEF dem_iff          : PTR TO iffhandle
  409. DEF dem_res
  410.  
  411.   WriteF( '\n\tEnter path of the prefsfile => ' )
  412.   ReadStr( stdin, dem_path )
  413.  
  414.   IF FileLength( dem_path ) <= 0
  415.     WriteF( '\n\tFile "\s" does not exist !\n', dem_path )
  416.     help_WaitReturn()
  417.     RETURN
  418.   ENDIF
  419.  
  420.   dem_iff := AllocIFF()
  421.   IF dem_iff <> NIL
  422.  
  423.     dem_iff.stream := Open( dem_path, OLDFILE )
  424.     IF dem_iff.stream <> NIL
  425.  
  426.       InitIFFasDOS( dem_iff )
  427.       IF OpenIFF( dem_iff, IFFF_READ ) = 0
  428.  
  429.         StopOnExit( dem_iff, ID_PREF, ID_FORM )
  430.         PropChunk( dem_iff, ID_PREF, ID_PRHD )
  431.         PropChunk( dem_iff, ID_PREF, ID_CCCP )
  432.  
  433.         -> search the selected chunks
  434.         dem_res  := ParseIFF( dem_iff, IFFPARSE_SCAN )
  435.         dem_prhd := FindProp( dem_iff, ID_PREF, ID_PRHD )
  436.         dem_cccp := FindProp( dem_iff, ID_PREF, ID_CCCP )
  437.  
  438.         -> valid chunks ?
  439.         IF ((dem_res = IFFERR_EOF) OR (dem_res = IFFERR_EOC)) AND (dem_prhd <> NIL) AND (dem_cccp <> NIL)
  440.  
  441.           WriteF( '\n\tVersion of the prefsfile : \d\n', dem_prhd.data::prefheader.version )
  442.  
  443.           -> here ! this is a simple way of setting the prefs.
  444.           SetAttrsA( dem_object, [ CCA_PREFSCHUNK, dem_cccp, TAG_END ] )
  445.           WriteF( '\tLoaded prefs are setted !\n' )
  446.           help_WaitReturn()
  447.  
  448.         ENDIF
  449.  
  450.         CloseIFF( dem_iff )
  451.  
  452.       ENDIF
  453.       Close( dem_iff.stream )
  454.  
  455.     ELSE
  456.       WriteF( '\n\tCannot open file "\s" !\n', dem_path )
  457.       help_WaitReturn()
  458.     ENDIF
  459.  
  460.     FreeIFF( dem_iff )
  461.  
  462.   ELSE
  463.     WriteF( '\n\tCan\at get an IFF-Handle !\n' )
  464.     help_WaitReturn()
  465.   ENDIF
  466.  
  467. ENDPROC
  468. ->»»>
  469.  
  470. ->»» PROC dem_SavePrefs
  471. PROC dem_SavePrefs( dem_object )
  472. DEF dem_path [ 200 ] : STRING
  473. DEF dem_cccp         : PTR TO storedproperty
  474. DEF dem_iff          : PTR TO iffhandle
  475. DEF dem_data
  476.  
  477.   WriteF( '\n\tEnter path of the prefsfile => ' )
  478.   ReadStr( stdin, dem_path )
  479.  
  480.   dem_iff := AllocIFF()
  481.   IF dem_iff <> NIL
  482.  
  483.     dem_iff.stream := Open( dem_path, NEWFILE )
  484.     IF dem_iff.stream <> NIL
  485.  
  486.       InitIFFasDOS( dem_iff )
  487.       IF OpenIFF( dem_iff, IFFF_WRITE ) = 0
  488.  
  489.         PushChunk( dem_iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN )
  490.  
  491.         dem_data := [ 1, 0, 0 ]:prefheader
  492.         PushChunk( dem_iff, ID_PREF, ID_PRHD, SIZEOF prefheader )
  493.         WriteChunkBytes( dem_iff, dem_data, SIZEOF prefheader )
  494.         PopChunk( dem_iff )
  495.  
  496.         -> this chunk must be saved
  497.         GetAttr( CCA_PREFSCHUNK, dem_object, {dem_cccp} )
  498.  
  499.         -> here we are storing our chunk
  500.         PushChunk( dem_iff, ID_PREF, ID_CCCP, dem_cccp.size )
  501.         WriteChunkBytes( dem_iff, dem_cccp.data, dem_cccp.size )
  502.         PopChunk( dem_iff )
  503.  
  504.         PopChunk( dem_iff )
  505.  
  506.         CloseIFF( dem_iff )
  507.  
  508.         WriteF( '\n\tWriting the prefs was successful !\n' )
  509.         help_WaitReturn()
  510.  
  511.       ENDIF
  512.       Close( dem_iff.stream )
  513.  
  514.     ELSE
  515.       WriteF( '\n\tCannot open file "\s" !\n', dem_path )
  516.       help_WaitReturn()
  517.     ENDIF
  518.  
  519.     FreeIFF( dem_iff )
  520.  
  521.   ELSE
  522.     WriteF( '\n\tCan\at get an IFF-Handle !\n' )
  523.     help_WaitReturn()
  524.   ENDIF
  525.  
  526. ENDPROC
  527. ->»»>
  528.  
  529. ->»» PROC dem_ToggleMemPool
  530. PROC dem_ToggleMemPool( dem_object )
  531. DEF dem_pool
  532.  
  533.   GetAttr( CCA_MEMPOOL, dem_object, {dem_pool} )
  534.   IF dem_pool <> NIL
  535.     SetAttrsA( dem_object, [ CCA_MEMPOOL, NIL, TAG_END ] )
  536.     WriteF( '\n\tMemory pool has been removed !\n' )
  537.   ELSE
  538.     SetAttrsA( dem_object, [ CCA_MEMPOOL, glo_mempool, TAG_END ] )
  539.     WriteF( '\n\tMemory pool has been installed !\n' )
  540.   ENDIF
  541.   help_WaitReturn()
  542.  
  543. ENDPROC
  544. ->»»>
  545.  
  546. ->»» PROC dem_ToggleProgress
  547. PROC dem_ToggleProgress( dem_object )
  548. DEF dem_flag
  549.   GetAttr( CCA_INTERNALPROGRESS, dem_object, {dem_flag} )
  550.   SetAttrsA( dem_object, [ CCA_INTERNALPROGRESS, Not( dem_flag ), TAG_END ] )
  551.   IF dem_flag = FALSE
  552.     Vprintf( 'Internal Progress-Hook installed !\n', NIL )
  553.   ELSE
  554.     Vprintf( 'Internal Progress-Hook removed !\n', NIL )
  555.   ENDIF
  556.   help_WaitReturn()
  557. ENDPROC
  558. ->»»>
  559.  
  560. ->»» PROC dem_File2File
  561. PROC dem_File2File( dem_object, dem_compressing )
  562. DEF dem_infile  [ 200 ] : STRING
  563. DEF dem_outfile [ 200 ] : STRING
  564. DEF dem_msg             : ccmFile2File
  565. DEF dem_xerr
  566.  
  567.   WriteF( '\n\tPath of the file to ' )
  568.   IF dem_compressing = FALSE THEN WriteF( 'de' )
  569.   WriteF( 'compress => ' )
  570.   ReadStr( stdin, dem_infile )
  571.  
  572.   IF FileLength( dem_infile ) > 0
  573.  
  574.     WriteF( '\tPath of the destination-file => ' )
  575.     ReadStr( stdin, dem_outfile )
  576.  
  577.     WriteF( '\n' )
  578.  
  579.     -> here a file will be compressed
  580.     dem_msg.methodid        := CCM_FILE2FILE
  581.     dem_msg.com_Source      := dem_infile
  582.     dem_msg.com_Destination := dem_outfile
  583.     dem_msg.com_Compressing := dem_compressing
  584.  
  585.     dem_xerr := doMethodA( dem_object, dem_msg )
  586.     IF dem_xerr = FALSE
  587.       WriteF( '\n\tFile "\s" was ', dem_infile )
  588.       IF dem_compressing = FALSE THEN WriteF( 'de' )
  589.       WriteF( 'compressed from \d to \d Bytes\n', FileLength( dem_infile ), FileLength( dem_outfile ) )
  590.     ELSE
  591.       WriteF( '\n\tDamn, an error occured ! XPK-Error = ' )
  592.       help_ShowXPKError( dem_xerr )
  593.     ENDIF
  594.  
  595.   ELSE
  596.     WriteF( 'The file "\s" doesn\at exist !\n', dem_infile )
  597.   ENDIF
  598.  
  599.   help_WaitReturn()
  600.  
  601. ENDPROC
  602. ->»»>
  603.  
  604. ->»» PROC dem_CompressFiles2Files
  605. PROC dem_CompressFiles2Files( dem_object )
  606. DEF dem_basename [  30 ]     : STRING
  607. DEF dem_buffer   [ 200 ]     : STRING
  608. DEF dem_strings  [ NILLIST ] : ARRAY OF LONG
  609. DEF dem_results  [ NILLIST ] : ARRAY OF LONG
  610. DEF dem_files2files          : ccmFiles2Files
  611. DEF dem_size,dem_number
  612. DEF dem_err,dem_len
  613.  
  614.   -> make sure the array are NIL-terminated
  615.   dem_strings[ NUMFILES ] := NIL
  616.   dem_results[ NUMFILES ] := NIL
  617.  
  618.   -> As you can see I prefer to use a suffix instead
  619.   -> of a list with destination-names.
  620.   dem_files2files.methodid         := CCM_FILES2FILES
  621.   dem_files2files.com_Compressing  := TRUE
  622.   dem_files2files.com_Sources      := dem_strings
  623.   dem_files2files.com_Destinations := NIL
  624.   dem_files2files.com_Results      := dem_results
  625.   dem_files2files.com_Suffix       := 'lurf'
  626.  
  627.   dem_size   := Div( Shr( AvailMem(0), SIZESHIFT ), NUMFILES )
  628.  
  629.   WriteF( '\n\tEnter a basename for the files => ' )
  630.   ReadStr( stdin, dem_basename )
  631.  
  632.   -> allocate memory for the strings
  633.   dem_len := StrLen( dem_basename ) + 8
  634.   dem_err := FALSE
  635.   FOR dem_number := 0 TO NUMFILES - 1
  636.     dem_strings[ dem_number ] := String( dem_len )
  637.     IF dem_strings[ dem_number ] = NIL THEN dem_err := TRUE
  638.   ENDFOR
  639.  
  640.   -> Damn, something went wrong
  641.   IF dem_err <> FALSE
  642.     WriteF( '\n\tNot enough memory available !\n' )
  643.     help_WaitReturn()
  644.     RETURN
  645.   ENDIF
  646.  
  647.   -> generate the files
  648.   Vprintf( '\n\tGenerating \d files with the size %lu Bytes:\n\n', [ dem_number, dem_size ] )
  649.   FOR dem_number := 0 TO NUMFILES - 1
  650.     stringf( dem_strings[ dem_number ], 'Ram:\s.\d', [ dem_basename, dem_number ] )
  651.     help_WriteDummyFile( dem_strings[ dem_number ], dem_size )
  652.     WriteF( '\n\tGenerated "\s"', dem_strings[ dem_number ] )
  653.   ENDFOR
  654.  
  655.   -> here we are running the method
  656.   dem_err    := doMethodA( dem_object, dem_files2files )
  657.   WriteF( '\n\t\d files were processed successfully !\n', dem_err )
  658.  
  659.   FOR dem_number := 0 TO NUMFILES - 1
  660.     IF dem_results[ dem_number ] <> XPKERR_OK
  661.       WriteF( '\tFile "\s" failed ! XPK-Error: ', dem_strings[ dem_number ] )
  662.       help_ShowXPKError( dem_results[ dem_number ] )
  663.     ELSE
  664.       stringf( dem_buffer, '\s.lurf', [ dem_strings[ dem_number ] ] )
  665.       WriteF( '\tCompressed "\s" to "\s" (\d Bytes)\n', dem_strings[ dem_number ], dem_buffer, FileLength( dem_buffer ) )
  666.     ENDIF
  667.   ENDFOR
  668.  
  669.   help_WaitReturn()
  670.  
  671. ENDPROC
  672. ->»»>
  673.  
  674. ->»» PROC dem_DecompressFiles2Files
  675. PROC dem_DecompressFiles2Files( dem_object )
  676. DEF dem_basename [  30 ]     : STRING
  677. DEF dem_buffer   [ 200 ]     : STRING
  678. DEF dem_strings  [ NILLIST ] : ARRAY OF LONG
  679. DEF dem_results  [ NILLIST ] : ARRAY OF LONG
  680. DEF dem_files2files          : ccmFiles2Files
  681. DEF dem_number,dem_err,dem_len
  682.  
  683.   -> make sure the array are NIL-terminated
  684.   dem_strings[ NUMFILES ] := NIL
  685.   dem_results[ NUMFILES ] := NIL
  686.  
  687.   -> As you can see I prefer to use a suffix instead
  688.   -> of a list with destination-names.
  689.   dem_files2files.methodid         := CCM_FILES2FILES
  690.   dem_files2files.com_Compressing  := FALSE
  691.   dem_files2files.com_Sources      := dem_strings
  692.   dem_files2files.com_Destinations := NIL
  693.   dem_files2files.com_Results      := dem_results
  694.   dem_files2files.com_Suffix       := 'lurf'
  695.  
  696.   WriteF( '\n\tEnter a basename for the files => ' )
  697.   ReadStr( stdin, dem_basename )
  698.  
  699.   -> allocate memory for the strings
  700.   dem_len := StrLen( dem_basename ) + 13
  701.   dem_err := FALSE
  702.   FOR dem_number := 0 TO NUMFILES - 1
  703.     dem_strings[ dem_number ] := String( dem_len )
  704.     IF dem_strings[ dem_number ] = NIL
  705.       dem_err := TRUE
  706.     ELSE
  707.       stringf( dem_strings[ dem_number ], 'ram:\s.\d.lurf', [ dem_basename, dem_number ] )
  708.     ENDIF
  709.   ENDFOR
  710.  
  711.   -> Damn, something went wrong
  712.   IF dem_err <> FALSE
  713.     WriteF( '\n\tNot enough memory available !\n' )
  714.     help_WaitReturn()
  715.     RETURN
  716.   ENDIF
  717.  
  718.   -> here we are running the method
  719.   dem_err    := doMethodA( dem_object, dem_files2files )
  720.   WriteF( '\n\t\d files were processed successfully !\n', dem_err )
  721.  
  722.   FOR dem_number := 0 TO NUMFILES - 1
  723.     IF dem_results[ dem_number ] <> XPKERR_OK
  724.       WriteF( '\tFile "\s" failed ! XPK-Error: ', dem_strings[ dem_number ] )
  725.       help_ShowXPKError( dem_results[ dem_number ] )
  726.     ELSE
  727.       AstrCopy( dem_buffer, dem_strings[ dem_number ], StrLen( dem_strings[ dem_number ] ) - 4 )
  728.       WriteF( '\tDecompressed "\s" to "\s" (\d Bytes)\n', dem_strings[ dem_number ], dem_buffer, FileLength( dem_buffer ) )
  729.     ENDIF
  730.   ENDFOR
  731.  
  732.   help_WaitReturn()
  733.  
  734. ENDPROC
  735. ->»»>
  736.  
  737. ->»» PROC dem_File2Mem
  738. PROC dem_File2Mem( dem_object, dem_compressing )
  739. DEF dem_infile [ 200 ] : STRING
  740. DEF dem_file2mem       : ccmFile2Mem
  741. DEF dem_pool,dem_length,dem_endlen
  742. DEF dem_mem,dem_xerr
  743.  
  744.   WriteF( '\n\tPath of the file to ' )
  745.   IF dem_compressing = FALSE THEN WriteF( 'de' )
  746.   WriteF( 'compress => ' )
  747.   ReadStr( stdin, dem_infile )
  748.  
  749.   IF FileLength( dem_infile ) <= 0
  750.     WriteF( '\n\tFile "\s" doesn\at exist !\n', dem_infile )
  751.     help_WaitReturn()
  752.     RETURN
  753.   ENDIF
  754.  
  755.   GetAttr( CCA_MEMPOOL, dem_object, {dem_pool} )
  756.   IF dem_pool <> NIL
  757.  
  758.     -> a memory pool is installed, so we are
  759.     -> using this pool
  760.     dem_file2mem.com_Memory := {dem_mem}
  761.     dem_file2mem.com_Length := 0          -> this is needed to use the pool
  762.  
  763.   ELSE
  764.  
  765.     -> we must allocate the memory by ourself
  766.  
  767.     -> find out the needed length
  768.     IF dem_compressing <> FALSE
  769.       dem_length := PACKSIZE( FileLength( dem_infile ) )
  770.     ELSE
  771.       doMethodA( dem_object, [ CCM_EXAMINE, dem_infile, NIL, 0, {dem_length} ]:ccmExamine )
  772.       dem_length := UNPACKSIZE( dem_length )
  773.     ENDIF
  774.  
  775.     dem_mem := AllocMem( dem_length, MEMF_PUBLIC )
  776.     IF dem_mem = NIL
  777.       WriteF( '\n\tCannot allocate enough memory !\n' )
  778.       help_WaitReturn()
  779.       RETURN
  780.     ENDIF
  781.  
  782.     dem_file2mem.com_Memory := dem_mem
  783.     dem_file2mem.com_Length := dem_length
  784.  
  785.   ENDIF
  786.  
  787.   dem_file2mem.methodid        := CCM_FILE2MEM
  788.   dem_file2mem.com_Compressing := dem_compressing
  789.   dem_file2mem.com_Source      := dem_infile
  790.   dem_file2mem.com_OutLen      := {dem_endlen}
  791.  
  792.   -> call the method
  793.   dem_xerr := doMethodA( dem_object, dem_file2mem )
  794.   IF dem_xerr = FALSE
  795.     WriteF( '\n\tCompression was successful !\n' )
  796.     IF dem_pool <> NIL
  797.       dem_length := MEMSIZE( dem_mem )
  798.       WriteF( '\tMemory pool was used !\n' )
  799.     ENDIF
  800.     WriteF( '\tMemory area at $\h ( \d Bytes )\n', dem_mem, dem_length )
  801.     WriteF( '\tCompressed data \d Bytes\n', dem_endlen )
  802.   ELSE
  803.     WriteF( '\n\tAn error occured ! XPK-Error: ' )
  804.     help_ShowXPKError( dem_xerr )
  805.   ENDIF
  806.   help_WaitReturn()
  807.  
  808.   IF dem_mem <> NIL
  809.     IF dem_pool <> NIL
  810.       FreePooled( glo_mempool, dem_mem - 4, dem_length )
  811.     ELSE
  812.       FreeMem( dem_mem, dem_length )
  813.     ENDIF
  814.   ENDIF
  815.  
  816. ENDPROC
  817. ->»»>
  818.  
  819. ->»» PROC dem_Mem2Mem
  820. PROC dem_Mem2Mem( dem_object, dem_compressing )
  821. DEF dem_infile [ 200 ] : STRING
  822. DEF dem_mem2mem        : ccmMem2Mem
  823. DEF dem_sourcemem,dem_sourcelen
  824. DEF dem_destmem,dem_destlen
  825. DEF dem_pool,dem_endlen,dem_xerr
  826.  
  827.   WriteF( '\n\tEnter path of the file to load into memory => ' )
  828.   ReadStr( stdin, dem_infile )
  829.  
  830.   dem_sourcemem,dem_sourcelen := help_LoadFile( dem_infile )
  831.   IF dem_sourcemem = NIL
  832.     WriteF( '\n\tCannot load file "\s" !\n', dem_infile )
  833.     help_WaitReturn()
  834.     RETURN
  835.   ENDIF
  836.  
  837.   GetAttr( CCA_MEMPOOL, dem_object, {dem_pool} )
  838.  
  839.   IF dem_pool <> NIL
  840.     dem_mem2mem.com_Destination    := {dem_destmem}
  841.     dem_mem2mem.com_DestinationLen := 0
  842.   ELSE
  843.  
  844.     IF dem_compressing <> FALSE
  845.       dem_destlen := PACKSIZE( dem_sourcelen )
  846.     ELSE
  847.       doMethodA( dem_object, [ CCM_EXAMINE, NIL, dem_sourcemem, dem_sourcelen, {dem_destlen} ]:ccmExamine )
  848.       dem_destlen := UNPACKSIZE( dem_destlen )
  849.     ENDIF
  850.  
  851.     dem_destmem := AllocMem( dem_destlen, MEMF_PUBLIC )
  852.     IF dem_destmem = NIL
  853.       WriteF( '\n\tCannot allocate enough memory !\n' )
  854.       FreeMem( dem_sourcemem, dem_sourcelen )
  855.       help_WaitReturn()
  856.       RETURN
  857.     ENDIF
  858.  
  859.     dem_mem2mem.com_Destination    := dem_destmem
  860.     dem_mem2mem.com_DestinationLen := dem_destlen
  861.  
  862.   ENDIF
  863.  
  864.   dem_mem2mem.methodid        := CCM_MEM2MEM
  865.   dem_mem2mem.com_Compressing := dem_compressing
  866.   dem_mem2mem.com_Source      := dem_sourcemem
  867.   dem_mem2mem.com_SourceLen   := dem_sourcelen
  868.   dem_mem2mem.com_OutLen      := {dem_endlen}
  869.  
  870.   dem_xerr := doMethodA( dem_object, dem_mem2mem )
  871.   IF dem_xerr = FALSE
  872.     WriteF( '\n\tOperation was successful !\n' )
  873.     IF dem_pool <> NIL
  874.       WriteF( '\tMemory pool was used !\n' )
  875.       dem_destlen := MEMSIZE( dem_destmem )
  876.     ENDIF
  877.     IF dem_compressing <> FALSE
  878.       WriteF( '\tCompressed ' )
  879.     ELSE
  880.       WriteF( '\tDecompressed ' )
  881.     ENDIF
  882.     WriteF( 'memory area $\h ( \d Bytes ) to $\h ( \d Bytes )\n', dem_sourcemem, dem_sourcelen, dem_destmem, dem_endlen )
  883.   ELSE
  884.     WriteF( '\n\tOperation failed ! XPK-Error: ' )
  885.     help_ShowXPKError( dem_xerr )
  886.   ENDIF
  887.   help_WaitReturn()
  888.  
  889.   IF dem_destmem <> NIL
  890.     IF dem_pool <> NIL
  891.       FreePooled( glo_mempool, dem_destmem - 4, dem_destlen )
  892.     ELSE
  893.       FreeMem( dem_destmem, dem_destlen )
  894.     ENDIF
  895.   ENDIF
  896.  
  897.   FreeMem( dem_sourcemem, dem_sourcelen )
  898.  
  899. ENDPROC
  900. ->»»>
  901.  
  902.  
  903. ->»» PROC dem_Menu
  904. PROC dem_Menu( men_object )
  905. DEF men_buffer[ 20 ] : STRING
  906. DEF men_end,men_choice
  907.  
  908.   -> Wow, what a modern style (Hehe) 
  909.  
  910.   men_end := FALSE
  911.  
  912.   WHILE men_end = FALSE
  913.  
  914.     help_ClearCON()
  915.  
  916.     Vprintf( {lab_ConfigMenu}, NIL )
  917.     IF iffparsebase <> NIL THEN Vprintf( {lab_IFFMenu}, NIL )
  918.     Vprintf( {lab_EndMenu}, NIL )
  919.     Flush( stdout )
  920.     ReadStr( stdin, men_buffer )
  921.  
  922.     men_choice := Val( men_buffer )
  923.  
  924.     help_ClearCON()
  925.     SELECT men_choice 
  926.     CASE  1  ; dem_ShowConfiguration ( men_object )
  927.     CASE  2  ; dem_SelectMethod      ( men_object )
  928.     CASE  3  ; dem_SelectMode        ( men_object )
  929.     CASE  4  ; dem_EnterPassword     ( men_object )
  930.     CASE  5  ; dem_ToggleHook        ( men_object )
  931.     CASE  6  ; dem_PopupGUI          ( men_object )
  932.     CASE  7  ; dem_HiddenPassword    ( men_object )
  933.     CASE 10  ; dem_ToggleMemPool     ( men_object )
  934.     CASE 19  ; dem_ToggleProgress    ( men_object )
  935.     CASE  8  ; IF iffparsebase <> NIL THEN dem_LoadPrefs( men_object )
  936.     CASE  9  ; IF iffparsebase <> NIL THEN dem_SavePrefs( men_object )
  937.     CASE 11  ; dem_File2File  ( men_object, TRUE  )
  938.     CASE 15  ; dem_File2File  ( men_object, FALSE )
  939.     CASE 14  ; dem_Mem2Mem    ( men_object, TRUE  )
  940.     CASE 18  ; dem_Mem2Mem    ( men_object, FALSE )
  941.     CASE 13  ; dem_File2Mem   ( men_object, TRUE  )
  942.     CASE 17  ; dem_File2Mem   ( men_object, FALSE )
  943.     CASE 12  ; dem_CompressFiles2Files   ( men_object )
  944.     CASE 16  ; dem_DecompressFiles2Files ( men_object )
  945.     CASE 20  ; men_end := TRUE
  946.     ENDSELECT
  947.  
  948.   ENDWHILE
  949.  
  950. ENDPROC
  951. ->»»>
  952.  
  953.  
  954. /* -- ----------------------------------------------------------------- -- *
  955.  * --                               Main                                -- *
  956.  * -- ----------------------------------------------------------------- -- */
  957.  
  958. ->»» PROC main
  959. PROC main() HANDLE
  960. DEF ma_object   : PTR TO object
  961. DEF ma_class    : PTR TO iclass
  962. DEF ma_clihook  : hook
  963.  
  964.   -> initialisation is necessary for proper exception-handling
  965.   ma_object := NIL
  966.  
  967.   -> make sure to be started from CLI
  968.   IF wbmessage <> NIL THEN Raise( ERR_NOWB )
  969.  
  970.   -> this library is needed for out configuration file
  971.   iffparsebase   := OpenLibrary( 'iffparse.library', 37 )
  972.  
  973.   -> open the class itself
  974.   compressorbase := OpenLibrary( 'compressor.class', 1 )
  975.   IF compressorbase = NIL THEN Raise( ERR_LIB )
  976.  
  977.   -> Never forget to get the class-pointer
  978.   ma_class := Cc_GetClassPtr()
  979.   IF ma_class = NIL THEN Raise( ERR_CLASS )
  980.  
  981.   -> install the progresshook
  982.   inithook( ma_clihook, {hoo_CLIProgress} )
  983.   glo_clihook := ma_clihook
  984.  
  985.   -> allocate a memory pool for demonstration reasons
  986.   glo_mempool := CreatePool( MEMF_PUBLIC, 500000, 25000 )
  987.  
  988.   -> create an object with initial tags
  989.   ma_object   := NewObjectA( ma_class , NIL ,
  990.   [ CCA_METHOD       , 'HUFF'               ,
  991.     CCA_MODE         , 100                  ,
  992.     CCA_PASSWORD     , 'Peter Lustig'       ,
  993.     CCA_PROGRESSHOOK , ma_clihook           ,
  994.     TAG_END ] )
  995.  
  996.   -> begin with the demonstration
  997.   IF ma_object <> NIL THEN dem_Menu( ma_object )
  998.  
  999. EXCEPT DO
  1000.  
  1001.   SELECT exception
  1002.   CASE ERR_LIB   ; WriteF( 'Wasn\at able to open the class.\n' )
  1003.   CASE ERR_ARGS  ; WriteF( 'Bad Args !\n' )
  1004.   CASE ERR_CLASS ; WriteF( 'No class available !\n' )
  1005.   CASE ERR_NOWB  ; WriteF( 'You must run this proggy from a shell !\n' )
  1006.   ENDSELECT
  1007.  
  1008.   IF ma_object      <> NIL THEN DisposeObject( ma_object )
  1009.   IF glo_mempool    <> NIL THEN DeletePool( glo_mempool )
  1010.   IF iffparsebase   <> NIL THEN CloseLibrary( iffparsebase   )
  1011.   IF compressorbase <> NIL THEN CloseLibrary( compressorbase )
  1012.  
  1013. ENDPROC
  1014. ->»»>
  1015.  
  1016.  
  1017. /* -- ----------------------------------------------------------------- -- *
  1018.  * --                               Data                                -- *
  1019.  * -- ----------------------------------------------------------------- -- */
  1020.  
  1021. lab_ConfigMenu:
  1022. CHAR '          +-------------------------------------+\n',
  1023.      '          |             \e[1;1mCONFIGURATION\e[0m           |\n',
  1024.      '          +-------------------------------------+\n',
  1025.      '          | 01. Show configuration              |\n',
  1026.      '          | 02. Select a method                 |\n',
  1027.      '          | 03. Select the mode                 |\n',
  1028.      '          | 04. Enter a password                |\n',
  1029.      '          | 05. Toggle hook installation        |\n',
  1030.      '          | 06. Use GUI for configuration       |\n',
  1031.      '          | 07. Toggle hidden password          |\n',0
  1032.  
  1033. lab_IFFMenu:
  1034. CHAR '          | 08. Load configuration from file    |\n',
  1035.      '          | 09. Save configuration to file      |\n',0
  1036.  
  1037. lab_EndMenu:
  1038. CHAR '          | 10. Toggle memory pool installation |\n',
  1039.      '          | 19. Toggle internal progresshook    |\n',
  1040.      '+---------+-----------------+-+-----------------+---------+\n',
  1041.      '|         \e[1;1mCOMPRESSION\e[0m       | |        \e[1;1mDECOMPRESSION\e[0m      |\n',
  1042.      '+---------------------------+ +---------------------------+\n',
  1043.      '| 11. From file to file     | | 15. From file to file     |\n',
  1044.      '| 12. From files to files   | | 16. From files to files   |\n',
  1045.      '| 13. From file to memory   | | 17. From file to memory   |\n',
  1046.      '| 14. From memory to memory | | 18. From memory to memory |\n',
  1047.      '+-------------+-------------+-+----------+----------------+\n',
  1048.      '              |  \e[2;1m20. Leave this program\e[0m  |\n',
  1049.      '              +--------------------------+\n\n',
  1050.      '  Your choice => ',0
  1051.  
  1052.  
  1053. CHAR '$VER: com_TestClass.e 1.0 (17-Sep-98) [ Daniel Kasmeroglu ]',0
  1054.